package com.hunttown.mes.common.utils;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * created by hunttown on 2017/9/13
 */
public class RegexpUtils {

    /**
     * 验证IPv4
     *
     * @param addr 验证IP
     * @return true or false
     */
    static Boolean isIP(String addr) {
        boolean ipAddress = false;

        try {
            if (addr.length() < 7 || addr.length() > 15) {
                return false;
            }

            String rexp = "([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}";
            Pattern pat = Pattern.compile(rexp);
            Matcher mat = pat.matcher(addr);
            ipAddress = mat.find();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return ipAddress;
    }

    /**
     * 将手机号中间4位替换成*
     *
     * @param phone 手机号
     * @return 158****0548
     */
    public static String hideMobileCode(String phone) {
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }

    /**
     * 手机号正则验证（简单版）
     *
     * @param mobile 手机号
     * @return TF
     */
    public static Boolean checkIsMobileSimple(String mobile) {

        // 定义手机号的规则
        String regex = "^1[3456789][0-9]{9}";

        // 比对mobile是否符合定义的规则
        return Pattern.matches(regex, mobile);
    }

    /**
     * 手机号正则验证
     * 默认可以使用两个中横线
     *
     * @param phone 手机号
     * @return TF
     */
    public static Boolean checkIsMobile(String phone) {
        if (phone.equals("--")) {
            return true;
        }

        /*
         * 移动号段：139、138、137、136、135、134、147、150、151、152、157、158、159、172、178、182、183、184、187、188、198
         * 联通号段：130、131、132、140、145、146、155、156、166、167、185、186、145、175、176
         * 电信号段：133、149、153、177、173、180、181、189、191、199 */

        String regex = "^((13[0-9])|(14[5,7,9])|(15([0-3]|[5-9]))|(16[5,6,7])|(17[0-8])|(18[0-9])|(19[1,5,8,9]))\\d{8}$";

        if (phone.length() != 11) {
            return false;
        } else {
            Pattern pat = Pattern.compile(regex);
            Matcher mat = pat.matcher(phone);
            return mat.matches();
        }
    }


    /**
     * 利用正则表达式判断字符串是否是 数字（包含浮点数）
     *
     * @param str 待验字符串
     * @return TF
     */
    public static boolean isNumeric(String str) {
        if (null == str || "".equals(str)) {
            return false;
        }

        Pattern pattern = Pattern.compile("^[0-9]+(.[0-9]+)?$");
        return pattern.matcher(str).matches();
    }

    /**
     * 利用正则表达式判断字符串是否是 整数
     *
     * @param str 待验字符串
     * @return TF
     */
    public static boolean isInteger(String str) {
        if (null == str || "".equals(str)) {
            return false;
        }

        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
    }

    /**
     * 利用正则表达式判断字符串是否是 浮点数
     *
     * @param str 待验字符串
     * @return TF
     */
    public static boolean isDouble(String str) {
        if (null == str || "".equals(str)) {
            return false;
        }
        Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
        return pattern.matcher(str).matches();
    }


    /**
     * 处理字符串：如果是数字则返回整型，不是则返回0
     *
     * @param str 待验字符串
     * @return 整数
     */
    public static Integer packageInt(String str) {
        if (StringUtils.isBlank(str)) {
            return 0;
        }

        if (isInteger(str)) {
            return Integer.valueOf(str);
        }

        return 0;
    }

    /**
     * 处理字符串：如果是数字则返回，不是则返回0
     *
     * @param str 待验字符串
     * @return 数字
     */
    public static BigDecimal packageDecimal(String str) {
        if (StringUtils.isBlank(str)) {
            new BigDecimal(0);
        }

        if (isDouble(str)) {
            return new BigDecimal(str);
        }

        return new BigDecimal(0);
    }

    /**
     * 利用正则表达式获取括号中的内容
     *
     * @param str 待验字符串
     * @return 括号中的内容
     */
    public static String getBrackets(String str) {
        if (null == str || "".equals(str)) {
            return "";
        }

        Pattern pattern = Pattern.compile("(?<=\\()(.+?)(?=\\))");
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            str = matcher.group(1);
        }

        return str;
    }

    /**
     * 获取P标签中的内容
     *
     * @param str  要过滤的内容
     * @param sort 第几个P标签的值
     * @return 匹配到的值
     */
    public static String getPContent(String str, Integer sort) {
        if (StringUtils.isBlank(str)) {
            return null;
        }

        if (sort == null || sort <= 0) {
            sort = 1;
        }

        String regStr = "<p>(.*?)</p>";
        Pattern pattern = Pattern.compile(regStr);
        Matcher m = pattern.matcher(str);

        String result = "";
        Integer i = 1;

        while (m.find()) {
            if (Objects.equals(i, sort)) {
                result = m.group(1);
                break;
            }
        }

        return result;
    }

    /**
     * 判断是否是字母
     *
     * @param str 传入字符串
     * @return 是字母返回true，否则返回false
     */
    public static boolean isLetter(String str) {
        if (StringUtils.isBlank(str)) {
            return false;
        }

        return str.matches("[a-zA-Z]+");
    }

    /**
     * 判断是否是日期
     *
     * @param str 传入字符串
     * @return TF
     */
    public static boolean isDate(String str) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            format.parse(str);
            return true;
        } catch (ParseException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 去掉字符串左边的0
     *
     * @param str 字符串
     * @return 结果
     */
    public static String removeLeftZero(String str) {
        return str.replaceAll("^(0+)", "");
    }

    //数据低前高后转化为正常顺序
    public static String computeRuntimeData(String signcode) {
        StringBuilder lastRes = new StringBuilder();
        for (int i = 0; i < signcode.length(); i = i + 2) {
            String sub = signcode.substring(i, i + 2);

            //由于原数据是：低前高后，所以组合的时候要往前面加
            lastRes.insert(0, sub);
        }
        return lastRes.toString();
    }

    public static void main(String[] args) throws Exception {

        /*
        System.out.println(isNumeric("14193522.23"));
        System.out.println(isNumeric("14193522"));
        System.out.println(isNumeric("abc"));
        System.out.println(isNumeric("3131abc"));
        */

        /*
        String mobile = "15410310548";
        System.out.println(checkIsMobileSimple(mobile));
        System.out.println(checkIsMobile(mobile));
        */

        System.out.println(isInteger("2358"));
        System.out.println(isInteger("02358"));
        System.out.println(isInteger("e2358"));
    }
}
